home *** CD-ROM | disk | FTP | other *** search
/ Sprite 1984 - 1993 / Sprite 1984 - 1993.iso / src / cmds / as / dist / read.c < prev    next >
Encoding:
C/C++ Source or Header  |  1989-08-03  |  52.5 KB  |  2,012 lines
  1. /* read.c - read a source file -
  2.    Copyright (C) 1986,1987 Free Software Foundation, Inc.
  3.  
  4. This file is part of GAS, the GNU Assembler.
  5.  
  6. GAS is free software; you can redistribute it and/or modify
  7. it under the terms of the GNU General Public License as published by
  8. the Free Software Foundation; either version 1, or (at your option)
  9. any later version.
  10.  
  11. GAS is distributed in the hope that it will be useful,
  12. but WITHOUT ANY WARRANTY; without even the implied warranty of
  13. MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14. GNU General Public License for more details.
  15.  
  16. You should have received a copy of the GNU General Public License
  17. along with GAS; see the file COPYING.  If not, write to
  18. the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
  19.  
  20. #define MASK_CHAR (0xFF)    /* If your chars aren't 8 bits, you will
  21.                    change this a bit.  But then, GNU isn't
  22.                    spozed to run on your machine anyway.
  23.                    (RMS is so shortsighted sometimes.)
  24.                  */
  25.  
  26. #define MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT (16)
  27.                 /* This is the largest known floating point */
  28.                 /* format (for now). It will grow when we */
  29.                 /* do 4361 style flonums. */
  30.  
  31.  
  32. /* Routines that read assembler source text to build spagetti in memory. */
  33. /* Another group of these functions is in the as-expr.c module */
  34.  
  35. #include <ctype.h>
  36. #include <sys/types.h>
  37. #include <sys/stat.h>
  38. #include "as.h"
  39. #include "read.h"
  40. #include "md.h"
  41. #include "hash.h"
  42. #include "obstack.h"
  43. #include "frags.h"
  44. #include "flonum.h"
  45. #include "struc-symbol.h"
  46. #include "expr.h"
  47. #include "symbols.h"
  48.  
  49. #ifdef SPARC
  50. #include "sparc.h"
  51. #endif
  52.  
  53. char *    input_line_pointer;    /* -> next char of source file to parse. */
  54.  
  55.  
  56. #if BITS_PER_CHAR != 8
  57. The following table is indexed by [ (char) ] and will break if
  58. a char does not have exactly 256 states (hopefully 0:255!) !
  59. #endif
  60.  
  61. char                /* used by is_... macros. our ctype[] */
  62. lex_type [256] = {
  63.   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,       /* @ABCDEFGHIJKLMNO */
  64.   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,       /* PQRSTUVWXYZ[\]^_ */
  65.   0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0,       /* _!"#$%&'()*+,-./ */
  66.   1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0,       /* 0123456789:;<=>? */
  67.   0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,       /* @ABCDEFGHIJKLMNO */
  68.   3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 3,       /* PQRSTUVWXYZ[\]^_ */
  69.   0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,       /* `abcdefghijklmno */
  70.   3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0,       /* pqrstuvwxyz{|}~. */
  71.   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  72.   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  73.   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  74.   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  75.   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  76.   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  77.   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 
  78. };
  79.  
  80.  
  81. /*
  82.  * In: a character.
  83.  * Out: TRUE if this character ends a line.
  84.  */
  85. #define _ (0)
  86. char is_end_of_line [256] = {
  87.  _, _, _, _, _, _, _, _, _, _,99, _, _, _, _, _, /* @abcdefghijklmno */
  88.  _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, /*                  */
  89.  _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, /*                  */
  90.  _, _, _, _, _, _, _, _, _, _, _,99, _, _, _, _, /* 0123456789:;<=>? */
  91.  _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, /*                  */
  92.  _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, /*                  */
  93.  _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, /*                  */
  94.  _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, /*                  */
  95.  _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, /*                  */
  96.  _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, /*                  */
  97.  _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, /*                  */
  98.  _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, /*                  */
  99.  _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _  /*                  */
  100. };
  101. #undef _
  102.  
  103.                 /* Functions private to this file. */
  104. void            equals();
  105. void            big_cons();
  106. void            cons();
  107. static char*        demand_copy_C_string();
  108. static char*        demand_copy_string();
  109. void            demand_empty_rest_of_line();
  110. void            float_cons();
  111. long int        get_absolute_expression();
  112. static char        get_absolute_expression_and_terminator();
  113. static segT        get_known_segmented_expression();
  114. void            ignore_rest_of_line();
  115. static int        is_it_end_of_statement();
  116. static void        pobegin();
  117. static void        pseudo_set();
  118. static void        stab();
  119. static void        stringer();
  120.  
  121. extern char line_comment_chars[];
  122.  
  123. static char *    buffer_limit;    /* -> 1 + last char in buffer. */
  124.  
  125. static char *    bignum_low;    /* Lowest char of bignum. */
  126. static char *    bignum_limit;    /* 1st illegal address of bignum. */
  127. static char *    bignum_high;    /* Highest char of bignum. */
  128.                 /* May point to (bignum_start-1). */
  129.                 /* Never >= bignum_limit. */
  130. static char *old_buffer = 0;    /* JF a hack */
  131. static char *old_input;
  132. static char *old_limit;
  133.  
  134. #ifndef WORKING_DOT_WORD
  135. struct broken_word *broken_words;
  136. int new_broken_words = 0;
  137. #endif
  138.  
  139. static void grow_bignum ();
  140. static int next_char_of_string ();
  141.  
  142. void
  143. read_begin()
  144. {
  145.   pobegin();
  146.   obstack_begin( ¬es, 5000 );
  147. #define BIGNUM_BEGIN_SIZE (16)
  148.   bignum_low = xmalloc((long)BIGNUM_BEGIN_SIZE);
  149.   bignum_limit = bignum_low + BIGNUM_BEGIN_SIZE;
  150. }
  151.  
  152. /* set up pseudo-op tables */
  153.  
  154. static struct hash_control *
  155. po_hash = NULL;            /* use before set up: NULL-> address error */
  156.  
  157.  
  158. void    s_abort(),    s_align(),    s_comm(),    s_data();
  159. void    s_desc(),    s_even(),    s_file(),    s_fill();
  160. void    s_gdbbeg(),    s_gdbblock(),    s_gdbend(),    s_gdbsym();
  161. void    s_globl(),    s_lcomm(),    s_line(),    s_lsym();
  162. void    s_org(),    s_set(),    s_space(),    s_text();
  163. void    s_gdbline(),    s_gdblinetab();
  164.  
  165. void    stringer();
  166. void    cons();
  167. void    float_cons();
  168. void    big_cons();
  169. void    stab();
  170.  
  171. static pseudo_typeS
  172. potable[] =
  173. {
  174.   { "abort",    s_abort,    0    },
  175.   { "align",    s_align,    0    },
  176.   { "ascii",    stringer,    0    },
  177.   { "asciz",    stringer,    1    },
  178.   { "byte",    cons,        1    },
  179.   { "comm",    s_comm,        0    },
  180.   { "data",    s_data,        0    },
  181.   { "desc",    s_desc,        0    },
  182.   { "double",    float_cons,    'd'    },
  183.   { "file",    s_file,        0    },
  184.   { "fill",    s_fill,        0    },
  185.   { "float",    float_cons,    'f'    },
  186.   { "gdbbeg",    s_gdbbeg,    0    },
  187.   { "gdbblock",    s_gdbblock,    0    },
  188.   { "gdbend",    s_gdbend,    0    },
  189.   { "gdbsym",    s_gdbsym,    0    },
  190.   { "gdbline",    s_gdbline,    0    },
  191.   { "gdblinetab",s_gdblinetab,    0    },
  192.   { "globl",    s_globl,    0    },
  193.   { "int",    cons,        4    },
  194.   { "lcomm",    s_lcomm,    0    },
  195.   { "line",    s_line,        0    },
  196.   { "long",    cons,        4    },
  197.   { "lsym",    s_lsym,        0    },
  198.   { "octa",    big_cons,    16    },
  199.   { "org",    s_org,        0    },
  200.   { "quad",    big_cons,    8    },
  201.   { "set",    s_set,        0    },
  202.   { "short",    cons,        2    },
  203.   { "single",    float_cons,    'f'    },
  204.   { "space",    s_space,    0    },
  205.   { "stabd",    stab,        'd'    },
  206.   { "stabn",    stab,        'n'    },
  207.   { "stabs",    stab,        's'    },
  208.   { "text",    s_text,        0    },
  209. #ifndef SPARC
  210.   { "word",    cons,        2    },
  211. #endif
  212.   { NULL}    /* end sentinel */
  213. };
  214.  
  215. static void
  216. pobegin()
  217. {
  218.   char *    errtxt;        /* error text */
  219.   pseudo_typeS * pop;
  220.  
  221.   po_hash = hash_new();
  222.   errtxt = "";            /* OK so far */
  223.   for (pop=potable; pop->poc_name && !*errtxt; pop++)
  224.     {
  225.       errtxt = hash_insert (po_hash, pop->poc_name, (char *)pop);
  226.     }
  227.  
  228.   for(pop=md_pseudo_table; pop->poc_name && !*errtxt; pop++)
  229.       errtxt = hash_insert (po_hash, pop->poc_name, (char *)pop);
  230.  
  231.   if (*errtxt)
  232.     {
  233.       as_fatal ("error constructing pseudo-op table");
  234.     }
  235. }                /* pobegin() */
  236.  
  237. /*            read_a_source_file()
  238.  *
  239.  * File has already been opened, and will be closed by our caller.
  240.  *
  241.  * We read the file, putting things into a web that
  242.  * represents what we have been reading.
  243.  */
  244. void
  245. read_a_source_file (buffer)
  246.      char *    buffer;        /* 1st character of each buffer of lines is here. */
  247. {
  248.   register char        c;
  249.   register char *    s;    /* string of symbol, '\0' appended */
  250.   register int        temp;
  251.   /* register struct frag * fragP; JF unused */    /* a frag we just made */
  252.   pseudo_typeS    *pop;
  253.   void gdb_block_beg();
  254.   void gdb_block_position();
  255.   void gdb_block_end();
  256.   void gdb_symbols_fixup();
  257.  
  258.   subseg_new (SEG_TEXT, 0);
  259.   while ( buffer_limit = input_scrub_next_buffer (&buffer) )
  260.     {                /* We have another line to parse. */
  261.       know( buffer_limit [-1] == '\n' ); /* Must have a sentinel. */
  262.       input_line_pointer = buffer;
  263.  contin:    /* JF this goto is my fault I admit it.  Someone brave please re-write
  264.            the whole input section here?  Pleeze??? */
  265.       while ( input_line_pointer < buffer_limit )
  266.     {            /* We have more of this buffer to parse. */
  267.       /*
  268.        * We now have input_line_pointer -> 1st char of next line.
  269.        * If input_line_pointer [-1] == '\n' then we just
  270.        * scanned another line: so bump line counters.
  271.        */
  272.       if (input_line_pointer [-1] == '\n')
  273.         {
  274.           bump_line_counters ();
  275.         }
  276.       /*
  277.        * We are at the begining of a line, or similar place.
  278.        * We expect a well-formed assembler statement.
  279.        * A "symbol-name:" is a statement.
  280.        *
  281.        * Depending on what compiler is used, the order of these tests
  282.        * may vary to catch most common case 1st.
  283.        * Each test is independent of all other tests at the (top) level.
  284.        * PLEASE make a compiler that doesn't use this assembler.
  285.        * It is crufty to waste a compiler's time encoding things for this
  286.        * assembler, which then wastes more time decoding it.
  287.        * (And communicating via (linear) files is silly!
  288.        * If you must pass stuff, please pass a tree!)
  289.        */
  290.       if ( (c= * input_line_pointer ++) == '\t' || c == ' ' || c=='\f')
  291.         {
  292.           c = * input_line_pointer ++;
  293.         }
  294.       know( c != ' ' );    /* No further leading whitespace. */
  295.       /*
  296.        * C is the 1st significant character.
  297.        * Input_line_pointer points after that character.
  298.        */
  299.       if ( is_name_beginner(c) )
  300.         {            /* want user-defined label or pseudo/opcode */
  301.           s = -- input_line_pointer;
  302.           c = get_symbol_end(); /* name's delimiter */
  303.           /*
  304.            * C is character after symbol.
  305.            * That character's place in the input line is now '\0'.
  306.            * S points to the beginning of the symbol.
  307.            *   [In case of pseudo-op, s -> '.'.]
  308.            * Input_line_pointer -> '\0' where c was.
  309.            */
  310.           if ( c == ':' )
  311.         {
  312.           colon(s);    /* user-defined label */
  313.           * input_line_pointer ++ = ':'; /* Put ':' back for error messages' sake. */
  314.                 /* Input_line_pointer -> after ':'. */
  315.           SKIP_WHITESPACE();
  316.         }
  317.           else if(c=='=' || input_line_pointer[1]=='=')        /* JF deal with FOO=BAR */
  318.             {
  319.           equals(s);
  320.           demand_empty_rest_of_line();
  321.         }
  322.           else
  323.         {        /* expect pseudo-op or machine instruction */
  324.           if ( *s=='.' )
  325.             {
  326.               /*
  327.                * PSEUDO - OP.
  328.                *
  329.                * WARNING: c has next char, which may be end-of-line.
  330.                * We lookup the pseudo-op table with s+1 because we
  331.                * already know that the pseudo-op begins with a '.'.
  332.                */
  333.  
  334.               pop= (pseudo_typeS *) hash_find (po_hash, s+1);
  335.                 /* Put it back for error messages etc. */
  336.               * input_line_pointer = c;
  337.                 /* The following skip of whitespace is compulsory. */
  338.                 /* A well shaped space is sometimes all that seperates keyword from operands. */
  339.               if ( c == ' ' || c == '\t' )
  340.             {    /* Skip seperator after keyword. */
  341.               input_line_pointer ++;
  342.             }
  343.               /*
  344.                * Input_line is restored.
  345.                * Input_line_pointer -> 1st non-blank char
  346.                * after pseudo-operation.
  347.                */
  348.                 if(!pop) {
  349.               as_warn("Unknown pseudo-op");
  350.               ignore_rest_of_line();
  351.               break;
  352.             }
  353.             else
  354.               (*pop->poc_handler)(pop->poc_val);
  355.             }
  356.           else
  357.             {        /* machine instruction */
  358.               /* WARNING: c has char, which may be end-of-line. */
  359.               /* Also: input_line_pointer -> `\0` where c was. */
  360.               * input_line_pointer = c;
  361.               while ( ! is_end_of_line [* input_line_pointer] )
  362.             {
  363.               input_line_pointer ++;
  364.             }
  365.               c = * input_line_pointer;
  366.               * input_line_pointer = '\0';
  367.               md_assemble (s);    /* Assemble 1 instruction. */
  368.               * input_line_pointer ++ = c;
  369.               /* We resume loop AFTER the end-of-line from this instruction */
  370.             }        /* if (*s=='.') */
  371.         }        /* if c==':' */
  372.           continue;
  373.         }            /* if (is_name_beginner(c) */
  374.  
  375.  
  376.       if ( is_end_of_line [c] )
  377.         {            /* empty statement */
  378.           continue;
  379.         }
  380.  
  381.       if ( isdigit(c) )
  382.         {            /* local label  ("4:") */
  383.           temp = c - '0';
  384. #ifdef SUN_ASM_SYNTAX
  385.           if( *input_line_pointer=='$')
  386.         input_line_pointer++;
  387. #endif
  388.           if ( * input_line_pointer ++ == ':' )
  389.         {
  390.           local_colon (temp);
  391.         }
  392.           else
  393.         {
  394.           as_warn( "Spurious digit %d.", temp);
  395.           input_line_pointer -- ;
  396.           ignore_rest_of_line();
  397.         }
  398.           continue;
  399.         }
  400.       if(c && index(line_comment_chars,c)) {    /* Its a comment.  Better say APP or NO_APP */
  401.         char *ends;
  402.         char *strstr();
  403.         char    *new_buf;
  404.         char    *new_tmp;
  405.         int    new_length;
  406.         char    *tmp_buf = 0;
  407.         extern char *scrub_string,*scrub_last_string;
  408.         int    scrub_from_string();
  409.         void    scrub_to_string();
  410.  
  411.         bump_line_counters();
  412.         s=input_line_pointer;
  413.         if(strncmp(s,"APP\n",4))
  414.             continue;    /* We ignore it */
  415.         s+=4;
  416.  
  417.         ends=strstr(s,"#NO_APP\n");
  418.  
  419.         if(!ends) {
  420.             int    tmp_len;
  421.             int    num;
  422.  
  423.             /* The end of the #APP wasn't in this buffer.  We
  424.                keep reading in buffers until we find the #NO_APP
  425.                that goes with this #APP  There is one.  The specs
  426.                 guarentee it. . .*/
  427.             tmp_len=buffer_limit-s;
  428.             tmp_buf=xmalloc(tmp_len);
  429.             bcopy(s,tmp_buf,tmp_len);
  430.             do {
  431.                 new_tmp = input_scrub_next_buffer(&buffer);
  432.                 if(!new_tmp)
  433.                     break;
  434.                 else
  435.                     buffer_limit = new_tmp;
  436.                 input_line_pointer = buffer;
  437.                 ends = strstr(buffer,"#NO_APP\n");
  438.                 if(ends)
  439.                     num=ends-buffer;
  440.                 else
  441.                     num=buffer_limit-buffer;
  442.  
  443.                 tmp_buf=xrealloc(tmp_buf,tmp_len+num);
  444.                 bcopy(buffer,tmp_buf+tmp_len,num);
  445.                 tmp_len+=num;
  446.             } while(!ends);
  447.  
  448.             input_line_pointer= ends ? ends+8 : NULL;
  449.  
  450.             s=tmp_buf;
  451.             ends=s+tmp_len;
  452.  
  453.         } else {
  454.             input_line_pointer=ends+8;
  455.         }
  456.         new_buf=xmalloc(100);
  457.         new_length=100;
  458.         new_tmp=new_buf;
  459.  
  460.         scrub_string=s;
  461.         scrub_last_string = ends;
  462.         for(;;) {
  463.             int ch;
  464.  
  465.             ch=do_scrub_next_char(scrub_from_string,scrub_to_string);
  466.             if(ch==EOF) break;
  467.             *new_tmp++=ch;
  468.             if(new_tmp==new_buf+new_length) {
  469.                 new_buf=xrealloc(new_buf,new_length+100);
  470.                 new_tmp=new_buf+new_length;
  471.                 new_length+=100;
  472.             }
  473.         }
  474.  
  475.         if(tmp_buf)
  476.             free(tmp_buf);
  477.         old_buffer=buffer;
  478.         old_input=input_line_pointer;
  479.         old_limit=buffer_limit;
  480.         buffer=new_buf;
  481.         input_line_pointer=new_buf;
  482.         buffer_limit=new_tmp;
  483.         continue;
  484.       }
  485.  
  486.       as_warn("Junk character %d.",c);
  487.       ignore_rest_of_line();
  488.     }            /* while (input_line_pointer<buffer_limit )*/
  489.     if(old_buffer) {
  490.         bump_line_counters();
  491.         if(old_input == 0)
  492.             return;
  493.         buffer=old_buffer;
  494.         input_line_pointer=old_input;
  495.         buffer_limit=old_limit;
  496.         old_buffer = 0;
  497.         goto contin;
  498.     }
  499.     }                /* while (more bufrers to scan) */
  500. }                /* read_a_source_file() */
  501.  
  502. void
  503. s_abort()
  504. {
  505.     as_fatal(".abort detected.  Abandoning ship.");
  506. }
  507.  
  508. void
  509. s_align()
  510. {
  511.     register int temp;
  512.     register long int temp_fill;
  513.  
  514.     temp = get_absolute_expression ();
  515. #define MAX_ALIGNMENT (15)
  516.     if ( temp > MAX_ALIGNMENT )
  517.         as_warn("Alignment too large: %d. assumed.", temp = MAX_ALIGNMENT);
  518.     else if ( temp < 0 ) {
  519.         as_warn("Alignment negative. 0 assumed.");
  520.         temp = 0;
  521.     }
  522.     if ( *input_line_pointer == ',' ) {
  523.         input_line_pointer ++;
  524.         temp_fill = get_absolute_expression ();
  525.     } else
  526.         temp_fill = 0;
  527.     /* Only make a frag if we HAVE to. . . */
  528.     if ( temp && ! need_pass_2 )
  529.         frag_align (temp, (int)temp_fill);
  530.     demand_empty_rest_of_line();
  531. }
  532.  
  533. void
  534. s_comm()
  535. {
  536.     register char *name;
  537.     register char c;
  538.     register char *p;
  539.     register int temp;
  540.     register symbolS *    symbolP;
  541.  
  542.     name = input_line_pointer;
  543.     c = get_symbol_end();
  544.     /* just after name is now '\0' */
  545.     p = input_line_pointer;
  546.     *p = c;
  547.     SKIP_WHITESPACE();
  548.     if ( * input_line_pointer != ',' ) {
  549.         as_warn("Expected comma after symbol-name");
  550.         ignore_rest_of_line();
  551.         return;
  552.     }
  553.     input_line_pointer ++; /* skip ',' */
  554.     if ( (temp = get_absolute_expression ()) < 0 ) {
  555.         as_warn(".COMMon length (%d.) <0! Ignored.", temp);
  556.         ignore_rest_of_line();
  557.         return;
  558.     }
  559.     *p = 0;
  560.     symbolP = symbol_find_or_make (name);
  561.     *p = c;
  562.     if (   (symbolP -> sy_type & N_TYPE) != N_UNDF ||
  563.  symbolP -> sy_other != 0 || symbolP -> sy_desc != 0) {
  564.         as_warn( "Ignoring attempt to re-define symbol");
  565.         ignore_rest_of_line();
  566.         return;
  567.     }
  568.     if (symbolP -> sy_value) {
  569.         if (symbolP -> sy_value != temp)
  570.             as_warn( "Length of .comm \"%s\" is already %d. Not changed to %d.",
  571.  symbolP -> sy_name, symbolP -> sy_value, temp);
  572.     } else {
  573.         symbolP -> sy_value = temp;
  574.         symbolP -> sy_type |= N_EXT;
  575.     }
  576.     know( symbolP -> sy_frag == &zero_address_frag );
  577.     demand_empty_rest_of_line();
  578. }
  579.  
  580. void
  581. s_data()
  582. {
  583.     register int temp;
  584.  
  585.     temp = get_absolute_expression ();
  586.     subseg_new (SEG_DATA, (subsegT)temp);
  587.     demand_empty_rest_of_line();
  588. }
  589.  
  590. void
  591. s_desc()
  592. {
  593.     register char *name;
  594.     register char c;
  595.     register char *p;
  596.     register symbolS *    symbolP;
  597.     register int temp;
  598.  
  599.     /*
  600.      * Frob invented at RMS' request. Set the n_desc of a symbol.
  601.      */
  602.     name = input_line_pointer;
  603.     c = get_symbol_end();
  604.     p = input_line_pointer;
  605.     symbolP = symbol_table_lookup (name);
  606.     * p = c;
  607.     SKIP_WHITESPACE();
  608.     if ( * input_line_pointer != ',' ) {
  609.         *p = 0;
  610.         as_warn("Expected comma after name \"%s\"", name);
  611.         *p = c;
  612.         ignore_rest_of_line();
  613.     } else {
  614.         input_line_pointer ++;
  615.         temp = get_absolute_expression ();
  616.         *p = 0;
  617.         symbolP = symbol_find_or_make (name);
  618.         *p = c;
  619.         symbolP -> sy_desc = temp;
  620.     }
  621.     demand_empty_rest_of_line();
  622. }
  623.  
  624. void
  625. s_file()
  626. {
  627.     register char *s;
  628.     int    length;
  629.  
  630.     /* Some assemblers tolerate immediately following '"' */
  631.     if ( s = demand_copy_string( & length ) ) {
  632.         new_logical_line (s, -1);
  633.         demand_empty_rest_of_line();
  634.     }
  635. }
  636.  
  637. void
  638. s_fill()
  639. {
  640.     long int temp_repeat;
  641.     long int temp_size;
  642.     register long int temp_fill;
  643.     char    *p;
  644.  
  645.     if ( get_absolute_expression_and_terminator(& temp_repeat) != ',' ) {
  646.         input_line_pointer --; /* Backup over what was not a ','. */
  647.         as_warn("Expect comma after rep-size in .fill");
  648.         ignore_rest_of_line();
  649.         return;
  650.     }
  651.     if ( get_absolute_expression_and_terminator( & temp_size) != ',' ) {
  652.           input_line_pointer --; /* Backup over what was not a ','. */
  653.           as_warn("Expected comma after size in .fill");
  654.           ignore_rest_of_line();
  655.           return;
  656.     }
  657.     /*
  658.      * This is to be compatible with BSD 4.2 AS, not for any rational reason.
  659.      */
  660. #define BSD_FILL_SIZE_CROCK_8 (8)
  661.     if ( temp_size > BSD_FILL_SIZE_CROCK_8 ) {
  662.         as_warn(".fill size clamped to %d.", BSD_FILL_SIZE_CROCK_8);
  663.         temp_size = BSD_FILL_SIZE_CROCK_8 ;
  664.     } if ( temp_size < 0 ) {
  665.         as_warn("Size negative: .fill ignored.");
  666.         temp_size = 0;
  667.     } else if ( temp_repeat <= 0 ) {
  668.         as_warn("Repeat < 0, .fill ignored");
  669.         temp_size = 0;
  670.     }
  671.     temp_fill = get_absolute_expression ();
  672.     if ( temp_size && !need_pass_2 ) {
  673.         p = frag_var (rs_fill, (int)temp_size, (int)temp_size, (relax_substateT)0, (symbolS *)0, temp_repeat, (char *)0);
  674.         bzero (p, (int)temp_size);
  675. /*
  676.  * The magic number BSD_FILL_SIZE_CROCK_4 is from BSD 4.2 VAX flavoured AS.
  677.  * The following bizzare behaviour is to be compatible with above.
  678.  * I guess they tried to take up to 8 bytes from a 4-byte expression
  679.  * and they forgot to sign extend. Un*x Sux.
  680.  */
  681. #define BSD_FILL_SIZE_CROCK_4 (4)
  682.         md_number_to_chars (p, temp_fill, temp_size > BSD_FILL_SIZE_CROCK_4 ? BSD_FILL_SIZE_CROCK_4 : (int)temp_size);
  683. /*
  684.  * Note: .fill (),0 emits no frag (since we are asked to .fill 0 bytes)
  685.  * but emits no error message because it seems a legal thing to do.
  686.  * It is a degenerate case of .fill but could be emitted by a compiler.
  687.  */
  688.     }
  689.     demand_empty_rest_of_line();
  690. }
  691.  
  692. void
  693. s_gdbbeg()
  694. {
  695.     register int temp;
  696.  
  697.     temp = get_absolute_expression ();
  698.     if (temp < 0)
  699.         as_warn( "Block number <0. Ignored." );
  700.     else if (flagseen ['G'])
  701.         gdb_block_beg ( (long int) temp, frag_now, (long int)(obstack_next_free(& frags) - frag_now -> fr_literal));
  702.     demand_empty_rest_of_line ();
  703. }
  704.  
  705. void
  706. s_gdbblock()
  707. {
  708.     register int    position;
  709.     int    temp;
  710.  
  711.     if (get_absolute_expression_and_terminator (&temp) != ',') {
  712.         as_warn( "expected comma before position in .gdbblock");
  713.         --input_line_pointer;
  714.         ignore_rest_of_line ();
  715.         return;
  716.     }
  717.     position = get_absolute_expression ();
  718.     if (flagseen ['G'])
  719.         gdb_block_position ((long int) temp, (long int) position);
  720.     demand_empty_rest_of_line ();
  721. }
  722.  
  723. void
  724. s_gdbend()
  725. {
  726.     register int temp;
  727.  
  728.     temp = get_absolute_expression ();
  729.     if (temp < 0)
  730.         as_warn( "Block number <0. Ignored." );
  731.     else if (flagseen ['G'])
  732.         gdb_block_end ( (long int) temp, frag_now, (long int)(obstack_next_free(& frags) - frag_now -> fr_literal));
  733.     demand_empty_rest_of_line ();
  734. }
  735.  
  736. void
  737. s_gdbsym()
  738. {
  739.     register char *name,
  740.             *p;
  741.     register char c;
  742.     register symbolS *    symbolP;
  743.     register int temp;
  744.  
  745.     name = input_line_pointer;
  746.     c = get_symbol_end();
  747.     p = input_line_pointer;
  748.     symbolP = symbol_find_or_make (name);
  749.     *p = c;
  750.     SKIP_WHITESPACE();
  751.     if ( * input_line_pointer != ',' ) {
  752.         as_warn("Expected comma after name");
  753.         ignore_rest_of_line();
  754.         return;
  755.     }
  756.     input_line_pointer ++;
  757.     if ( (temp = get_absolute_expression ()) < 0 ) {
  758.         as_warn("Bad GDB symbol file offset (%d.) <0! Ignored.", temp);
  759.         ignore_rest_of_line();
  760.         return;
  761.     }
  762.     if (flagseen ['G'])
  763.         gdb_symbols_fixup (symbolP, (long int)temp);
  764.     demand_empty_rest_of_line ();
  765. }
  766.  
  767. void
  768. s_gdbline()
  769. {
  770.     int    file_number,
  771.         lineno;
  772.  
  773.     if(get_absolute_expression_and_terminator(&file_number) != ',') {
  774.         as_warn("expected comman after filenum in .gdbline");
  775.         ignore_rest_of_line();
  776.         return;
  777.     }
  778.     lineno=get_absolute_expression();
  779.     if(flagseen['G'])
  780.         gdb_line(file_number,lineno);
  781.     demand_empty_rest_of_line();
  782. }
  783.  
  784.  
  785. void
  786. s_gdblinetab()
  787. {
  788.     int    file_number,
  789.         offset;
  790.  
  791.     if(get_absolute_expression_and_terminator(&file_number) != ',') {
  792.         as_warn("expected comman after filenum in .gdblinetab");
  793.         ignore_rest_of_line();
  794.         return;
  795.     }
  796.     offset=get_absolute_expression();
  797.     if(flagseen['G'])
  798.         gdb_line_tab(file_number,offset);
  799.     demand_empty_rest_of_line();
  800. }
  801.     
  802.  
  803. void
  804. s_globl()
  805. {
  806.     register char *name;
  807.     register int c;
  808.     register symbolS *    symbolP;
  809.  
  810.     do {
  811.         name = input_line_pointer;
  812.         c = get_symbol_end();
  813.         symbolP = symbol_find_or_make (name);
  814.         * input_line_pointer = c;
  815.         SKIP_WHITESPACE();
  816.         symbolP -> sy_type |= N_EXT;
  817.         if(c==',') {
  818.             input_line_pointer++;
  819.             SKIP_WHITESPACE();
  820.             if(*input_line_pointer=='\n')
  821.                 c='\n';
  822.         }
  823.     } while(c==',');
  824.     demand_empty_rest_of_line();
  825. }
  826.  
  827. void
  828. s_lcomm()
  829. {
  830.     register char *name;
  831.     register char c;
  832.     register char *p;
  833.     register int temp;
  834.     register symbolS *    symbolP;
  835.  
  836.     name = input_line_pointer;
  837.     c = get_symbol_end();
  838.     p = input_line_pointer;
  839.     *p = c;
  840.     SKIP_WHITESPACE();
  841.     if ( * input_line_pointer != ',' ) {
  842.         as_warn("Expected comma after name");
  843.         ignore_rest_of_line();
  844.         return;
  845.     }
  846.     input_line_pointer ++;
  847.     if ( (temp = get_absolute_expression ()) < 0 ) {
  848.         as_warn("BSS length (%d.) <0! Ignored.", temp);
  849.         ignore_rest_of_line();
  850.         return;
  851.     }
  852.     *p = 0;
  853.     symbolP = symbol_find_or_make (name);
  854.     *p = c;
  855.     if (   symbolP -> sy_other == 0
  856.         && symbolP -> sy_desc  == 0
  857.         && (   (   symbolP -> sy_type  == N_BSS
  858.         && symbolP -> sy_value == local_bss_counter)
  859.         || (   (symbolP -> sy_type & N_TYPE) == N_UNDF
  860.         && symbolP -> sy_value == 0))) {
  861.         symbolP -> sy_value = local_bss_counter;
  862.         symbolP -> sy_type  = N_BSS;
  863.         symbolP -> sy_frag  = & bss_address_frag;
  864.         local_bss_counter += temp;
  865.     } else
  866.         as_warn( "Ignoring attempt to re-define symbol from %d. to %d.",
  867.  symbolP -> sy_value, local_bss_counter );
  868.     demand_empty_rest_of_line();
  869. }
  870.  
  871. void
  872. s_line()
  873. {
  874.     /* Assume delimiter is part of expression. */
  875.     /* BSD4.2 as fails with delightful bug, so we */
  876.     /* are not being incompatible here. */
  877.     new_logical_line ((char *)NULL, (int)(get_absolute_expression ()));
  878.     demand_empty_rest_of_line();
  879. }
  880.  
  881. void
  882. s_long()
  883. {
  884.     cons(4);
  885. }
  886.  
  887. void
  888. s_int()
  889. {
  890.     cons(4);
  891. }
  892.  
  893. void
  894. s_lsym()
  895. {
  896.     register char *name;
  897.     register char c;
  898.     register char *p;
  899.     register segT segment;
  900.     expressionS exp;
  901.     register symbolS *symbolP;
  902.  
  903.     /* we permit ANY expression: BSD4.2 demands constants */
  904.     name = input_line_pointer;
  905.     c = get_symbol_end();
  906.     p = input_line_pointer;
  907.     *p = c;
  908.     SKIP_WHITESPACE();
  909.     if ( * input_line_pointer != ',' ) {
  910.         *p = 0;
  911.         as_warn("Expected comma after name \"%s\"", name);
  912.         *p = c;
  913.         ignore_rest_of_line();
  914.         return;
  915.     }
  916.     input_line_pointer ++;
  917.     segment = expression (& exp);
  918.     if (   segment != SEG_ABSOLUTE && segment != SEG_DATA &&
  919.  segment != SEG_TEXT && segment != SEG_BSS) {
  920.         as_warn("Bad expression: %s", seg_name [(int)segment]);
  921.         ignore_rest_of_line();
  922.         return;
  923.     }
  924.  know(   segment == SEG_ABSOLUTE || segment == SEG_DATA || segment == SEG_TEXT || segment == SEG_BSS );
  925.     *p = 0;
  926.     symbolP = symbol_new (name,(unsigned char)(seg_N_TYPE [(int) segment]),
  927.  0, 0, (valueT)(exp . X_add_number), & zero_address_frag);
  928.     *p = c;
  929.     demand_empty_rest_of_line();
  930. }
  931.  
  932. void
  933. s_org()
  934. {
  935.     register segT segment;
  936.     expressionS exp;
  937.     register long int temp_fill;
  938.     register char *p;
  939. /*
  940.  * Don't believe the documentation of BSD 4.2 AS.
  941.  * There is no such thing as a sub-segment-relative origin.
  942.  * Any absolute origin is given a warning, then assumed to be segment-relative.
  943.  * Any segmented origin expression ("foo+42") had better be in the right
  944.  * segment or the .org is ignored.
  945.  *
  946.  * BSD 4.2 AS warns if you try to .org backwards. We cannot because we
  947.  * never know sub-segment sizes when we are reading code.
  948.  * BSD will crash trying to emit -ve numbers of filler bytes in certain
  949.  * .orgs. We don't crash, but see as-write for that code.
  950.  */
  951. /*
  952.  * Don't make frag if need_pass_2==TRUE.
  953.  */
  954.     segment = get_known_segmented_expression(& exp);
  955.     if ( *input_line_pointer == ',' ) {
  956.         input_line_pointer ++;
  957.         temp_fill = get_absolute_expression ();
  958.     } else
  959.         temp_fill = 0;
  960.     if ( ! need_pass_2 ) {
  961.         if (segment != now_seg && segment != SEG_ABSOLUTE)
  962.             as_warn("Illegal segment \"%s\". Segment \"%s\" assumed.",
  963.  seg_name [(int) segment], seg_name [(int) now_seg]);
  964.         p = frag_var (rs_org, 1, 1, (relax_substateT)0, exp . X_add_symbol,
  965.  exp . X_add_number, (char *)0);
  966.         * p = temp_fill;
  967.     } /* if (ok to make frag) */
  968.     demand_empty_rest_of_line();
  969. }
  970.  
  971. void
  972. s_set()
  973. {
  974.     register char *name;
  975.     register char delim;
  976.     register char *end_name;
  977.     register symbolS *symbolP;
  978.  
  979.     /*
  980.      * Especial apologies for the random logic:
  981.      * this just grew, and could be parsed much more simply!
  982.      * Dean in haste.
  983.      */
  984.     name = input_line_pointer;
  985.     delim = get_symbol_end();
  986.     end_name = input_line_pointer;
  987.     *end_name = delim;
  988.     SKIP_WHITESPACE();
  989.     if ( * input_line_pointer != ',' ) {
  990.         *end_name = 0;
  991.         as_warn("Expected comma after name \"%s\"", name);
  992.         *end_name = delim;
  993.         ignore_rest_of_line();
  994.         return;
  995.     }
  996.     input_line_pointer ++;
  997.     *end_name = 0;
  998.     if(name[0]=='.' && name[1]=='\0') {
  999.       /* Turn '. = mumble' into a .org mumble */
  1000.       register segT segment;
  1001.       expressionS exp;
  1002.       register char *ptr;
  1003.  
  1004.       segment = get_known_segmented_expression(& exp);
  1005.       if ( ! need_pass_2 ) {
  1006.         if (segment != now_seg && segment != SEG_ABSOLUTE)
  1007.           as_warn("Illegal segment \"%s\". Segment \"%s\" assumed.",
  1008.               seg_name [(int) segment], seg_name [(int) now_seg]);
  1009.         ptr = frag_var (rs_org, 1, 1, (relax_substateT)0, exp.X_add_symbol,
  1010.               exp.X_add_number, (char *)0);
  1011.         *ptr= 0;
  1012.       } /* if (ok to make frag) */
  1013.       *end_name = delim;
  1014.       return;
  1015.     }
  1016.     symbolP = symbol_find_or_make (name);
  1017.     *end_name = delim;
  1018.     pseudo_set (symbolP);
  1019.     demand_empty_rest_of_line ();
  1020. }
  1021.  
  1022. void
  1023. s_space()
  1024. {
  1025.     long int temp_repeat;
  1026.     register long int temp_fill;
  1027.     register char *p;
  1028.  
  1029.     /* Just like .fill, but temp_size = 1 */
  1030.     if ( get_absolute_expression_and_terminator( & temp_repeat) == ',' ) {
  1031.         temp_fill = get_absolute_expression ();
  1032.     } else {
  1033.         input_line_pointer --; /* Backup over what was not a ','. */
  1034.         temp_fill = 0;
  1035.     }
  1036.     if ( temp_repeat <= 0 ) {
  1037.         as_warn("Repeat < 0, .space ignored");
  1038.         ignore_rest_of_line();
  1039.         return;
  1040.     }
  1041.     if ( ! need_pass_2 ) {
  1042.         p = frag_var (rs_fill, 1, 1, (relax_substateT)0, (symbolS *)0,
  1043.  temp_repeat, (char *)0);
  1044.         * p = temp_fill;
  1045.     }
  1046.     demand_empty_rest_of_line();
  1047. }
  1048.  
  1049. void
  1050. s_text()
  1051. {
  1052.     register int temp;
  1053.  
  1054.     temp = get_absolute_expression ();
  1055.     subseg_new (SEG_TEXT, (subsegT)temp);
  1056.     demand_empty_rest_of_line();
  1057. }
  1058.  
  1059.  
  1060. /*( JF was static, but can't be if machine dependent pseudo-ops are to use it */
  1061.  
  1062. void
  1063. demand_empty_rest_of_line()
  1064. {
  1065.   SKIP_WHITESPACE();
  1066.   if ( is_end_of_line [* input_line_pointer] )
  1067.     {
  1068.       input_line_pointer ++;
  1069.     }
  1070.   else
  1071.     {
  1072.       ignore_rest_of_line();
  1073.     }
  1074.                 /* Return having already swallowed end-of-line. */
  1075. }                /* Return pointing just after end-of-line. */
  1076.  
  1077.  
  1078. void
  1079. ignore_rest_of_line()        /* For suspect lines: gives warning. */
  1080. {
  1081.   if ( ! is_end_of_line [* input_line_pointer])
  1082.     {
  1083.       as_warn("Rest of line ignored. 1st junk character valued %d."
  1084.           , * input_line_pointer);
  1085.       while (   input_line_pointer < buffer_limit
  1086.          && ! is_end_of_line [* input_line_pointer] )
  1087.     {
  1088.       input_line_pointer ++;
  1089.     }
  1090.     }
  1091.   input_line_pointer ++;    /* Return pointing just after end-of-line. */
  1092.   know( is_end_of_line [input_line_pointer [-1]] );
  1093. }
  1094.  
  1095. /*
  1096.  *            stab()
  1097.  *
  1098.  * Handle .stabX directives, which used to be open-coded.
  1099.  * So much creeping featurism overloaded the semantics that we decided
  1100.  * to put all .stabX thinking in one place. Here.
  1101.  *
  1102.  * We try to make any .stabX directive legal. Other people's AS will often
  1103.  * do assembly-time consistency checks: eg assigning meaning to n_type bits
  1104.  * and "protecting" you from setting them to certain values. (They also zero
  1105.  * certain bits before emitting symbols. Tut tut.)
  1106.  *
  1107.  * If an expression is not absolute we either gripe or use the relocation
  1108.  * information. Other people's assemblers silently forget information they
  1109.  * don't need and invent information they need that you didn't supply.
  1110.  *
  1111.  * .stabX directives always make a symbol table entry. It may be junk if
  1112.  * the rest of your .stabX directive is malformed.
  1113.  */
  1114. static void
  1115. stab (what)
  1116. int what;
  1117. {
  1118.   register symbolS *    symbolP;
  1119.   register char *    string;
  1120.        int        saved_type;
  1121.          int        length;
  1122.          int        goof;    /* TRUE if we have aborted. */
  1123.        long int    longint;
  1124.  
  1125. /*
  1126.  * Enter with input_line_pointer pointing past .stabX and any following
  1127.  * whitespace.
  1128.  */
  1129.     goof = FALSE; /* JF who forgot this?? */
  1130.     if (what == 's') {
  1131.         string = demand_copy_C_string (& length);
  1132.         SKIP_WHITESPACE();
  1133.         if (* input_line_pointer == ',')
  1134.             input_line_pointer ++;
  1135.         else {
  1136.             as_warn( "I need a comma after symbol's name" );
  1137.             goof = TRUE;
  1138.         }
  1139.     } else
  1140.         string = "";
  1141.  
  1142. /*
  1143.  * Input_line_pointer->after ','.  String -> symbol name.
  1144.  */
  1145.     if (! goof) {
  1146.         symbolP = symbol_new (string, 0,0,0,0,(struct frag *)0);
  1147.         switch (what) {
  1148.         case 'd':
  1149.             symbolP->sy_name = NULL; /* .stabd feature. */
  1150.             symbolP->sy_value = obstack_next_free(& frags) - frag_now->fr_literal;
  1151.             symbolP->sy_frag = frag_now;
  1152.             break;
  1153.  
  1154.         case 'n':
  1155.             symbolP->sy_frag = &zero_address_frag;
  1156.             break;
  1157.  
  1158.         case 's':
  1159.             symbolP->sy_frag = & zero_address_frag;
  1160.             break;
  1161.  
  1162.         default:
  1163.             BAD_CASE( what );
  1164.             break;
  1165.         }
  1166.         if (get_absolute_expression_and_terminator (& longint) == ',')
  1167.             symbolP->sy_type = saved_type = longint;
  1168.         else {
  1169.             as_warn( "I want a comma after the n_type expression" );
  1170.             goof = TRUE;
  1171.             input_line_pointer --; /* Backup over a non-',' char. */
  1172.         }
  1173.     }
  1174.     if (! goof) {
  1175.         if (get_absolute_expression_and_terminator (& longint) == ',')
  1176.             symbolP->sy_other = longint;
  1177.         else {
  1178.             as_warn( "I want a comma after the n_other expression" );
  1179.             goof = TRUE;
  1180.             input_line_pointer --; /* Backup over a non-',' char. */
  1181.         }
  1182.     }
  1183.     if (! goof) {
  1184.         symbolP->sy_desc = get_absolute_expression ();
  1185.         if (what == 's' || what == 'n') {
  1186.             if (* input_line_pointer != ',') {
  1187.                 as_warn( "I want a comma after the n_desc expression" );
  1188.                 goof = TRUE;
  1189.             } else {
  1190.                 input_line_pointer ++;
  1191.             }
  1192.         }
  1193.     }
  1194.     if ((! goof) && (what=='s' || what=='n')) {
  1195.         pseudo_set (symbolP);
  1196.         symbolP->sy_type = saved_type;
  1197.     }
  1198.     if (goof)
  1199.         ignore_rest_of_line ();
  1200.     else
  1201.         demand_empty_rest_of_line ();
  1202. }
  1203.  
  1204. /*
  1205.  *            pseudo_set()
  1206.  *
  1207.  * In:    Pointer to a symbol.
  1208.  *    Input_line_pointer -> expression.
  1209.  *
  1210.  * Out:    Input_line_pointer -> just after any whitespace after expression.
  1211.  *    Tried to set symbol to value of expression.
  1212.  *    Will change sy_type, sy_value, sy_frag;
  1213.  *    May set need_pass_2 == TRUE.
  1214.  */
  1215. static void
  1216. pseudo_set (symbolP)
  1217.      symbolS *    symbolP;
  1218. {
  1219.   expressionS    exp;
  1220.   register segT    segment;
  1221.  
  1222.   know( symbolP );        /* NULL pointer is logic error. */
  1223.   if ((segment = expression( & exp )) == SEG_NONE)
  1224.     {
  1225.       as_warn( "Missing expression: absolute 0 assumed" );
  1226.       exp . X_seg        = SEG_ABSOLUTE;
  1227.       exp . X_add_number    = 0;
  1228.     }
  1229.   switch (segment)
  1230.     {
  1231.     case SEG_BIG:
  1232.       as_warn( "%s number illegal. Absolute 0 assumed.",
  1233.           exp . X_add_number > 0 ? "Bignum" : "Floating-Point" );
  1234.       symbolP -> sy_type = N_ABS;
  1235.       symbolP -> sy_value = 0;
  1236.       symbolP -> sy_frag = & zero_address_frag;
  1237.       break;
  1238.  
  1239.     case SEG_NONE:
  1240.       as_warn("No expression:  Using absolute 0");
  1241.       symbolP -> sy_type = N_ABS;
  1242.       symbolP -> sy_value = 0;
  1243.       symbolP -> sy_frag = & zero_address_frag;
  1244.       break;
  1245.  
  1246.     case SEG_DIFFERENCE:
  1247.       if (exp.X_add_symbol && exp.X_subtract_symbol
  1248.           &&    (exp.X_add_symbol->sy_type & N_TYPE)
  1249.          == (exp.X_subtract_symbol->sy_type & N_TYPE))
  1250.     exp.X_add_number+=exp.X_add_symbol->sy_value - exp.X_subtract_symbol->sy_value;
  1251.       else
  1252.     as_warn( "Complex expression. Absolute segment assumed." );
  1253.     case SEG_ABSOLUTE:
  1254.       symbolP -> sy_type = N_ABS;
  1255.       symbolP -> sy_value = exp . X_add_number;
  1256.       symbolP -> sy_frag = & zero_address_frag;
  1257.       break;
  1258.  
  1259.     case SEG_DATA:
  1260.     case SEG_TEXT:
  1261.     case SEG_BSS:
  1262.       symbolP -> sy_type = seg_N_TYPE [(int) segment];
  1263.       symbolP -> sy_value= exp . X_add_number + exp . X_add_symbol -> sy_value;
  1264.       symbolP -> sy_frag = exp . X_add_symbol -> sy_frag;
  1265.       break;
  1266.       
  1267.     case SEG_PASS1:        /* Not an error. Just try another pass. */
  1268.       symbolP->sy_forward=exp.X_add_symbol;
  1269.       as_warn("Unknown expression");
  1270.       know( need_pass_2 == TRUE );
  1271.       break;
  1272.       
  1273.     case SEG_UNKNOWN:
  1274.       symbolP->sy_forward=exp.X_add_symbol;
  1275.       /* as_warn("unknown symbol"); */
  1276.       /* need_pass_2 = TRUE; */
  1277.       break;
  1278.       
  1279.     default:
  1280.       BAD_CASE( segment );
  1281.       break;
  1282.     }
  1283. }
  1284.  
  1285. /*
  1286.  *            cons()
  1287.  *
  1288.  * CONStruct more frag of .bytes, or .words etc.
  1289.  * Should need_pass_2 be TRUE then emit no frag(s).
  1290.  * This understands EXPRESSIONS, as opposed to big_cons().
  1291.  *
  1292.  * Bug (?)
  1293.  *
  1294.  * This has a split personality. We use expression() to read the
  1295.  * value. We can detect if the value won't fit in a byte or word.
  1296.  * But we can't detect if expression() discarded significant digits
  1297.  * in the case of a long. Not worth the crocks required to fix it.
  1298.  */
  1299. void
  1300. cons(nbytes)            /* worker to do .byte etc statements */
  1301.                 /* clobbers input_line_pointer, checks */
  1302.                 /* end-of-line. */
  1303.      register int    nbytes;    /* 1=.byte, 2=.word, 4=.long */
  1304. {
  1305.   register char        c;
  1306.   register long int    mask;    /* High-order bits we will left-truncate, */
  1307.                 /* but includes sign bit also. */
  1308.   register long int     get;    /* what we get */
  1309.   register long int    use;    /* get after truncation. */
  1310.   register long int    unmask;    /* what bits we will store */
  1311.   register char *    p;
  1312.   register segT        segment;
  1313.            expressionS    exp;
  1314. #ifdef NS32K
  1315.   void fix_new_ns32k();
  1316. #else
  1317.   void    fix_new();
  1318. #endif
  1319.  
  1320.   /*
  1321.    * Input_line_pointer -> 1st char after pseudo-op-code and could legally
  1322.    * be a end-of-line. (Or, less legally an eof - which we cope with.)
  1323.    */
  1324.   /* JF << of >= number of bits in the object is undefined.  In particular
  1325.      SPARC (Sun 4) has problems */
  1326.   if(nbytes>=sizeof(long int))
  1327.     mask = 0;
  1328.   else 
  1329.     mask = ~0 << (BITS_PER_CHAR * nbytes); /* Don't store these bits. */
  1330.   unmask = ~ mask;        /* Do store these bits. */
  1331. #ifdef NEVER
  1332.   "Do this mod if you want every overflow check to assume SIGNED 2's complement data.";
  1333.   mask = ~ (unmask >> 1);    /* Includes sign bit now. */
  1334. #endif
  1335.   /*
  1336.    * The following awkward logic is to parse ZERO or more expressions,
  1337.    * comma seperated. Recall an expression includes its leading &
  1338.    * trailing blanks. We fake a leading ',' if there is (supposed to
  1339.    * be) a 1st expression, and keep demanding 1 expression for each ','.
  1340.    */
  1341.   if (is_it_end_of_statement())
  1342.     {
  1343.       c = 0;            /* Skip loop. */
  1344.       input_line_pointer ++;    /* Matches end-of-loop 'correction'. */
  1345.     }
  1346.   else
  1347.       c = ',';            /* Do loop. */
  1348.   while ( c == ','  )
  1349.     {
  1350.       segment = expression( &exp ); /* At least scan over the expression. */
  1351.       if ( ! need_pass_2 )
  1352.     {            /* Still worthwhile making frags. */
  1353.  
  1354.       /* Don't call this if we are going to junk this pass anyway! */
  1355.       know( segment != SEG_PASS1 );
  1356.  
  1357.       if ( segment == SEG_DIFFERENCE && exp . X_add_symbol == NULL )
  1358.         {
  1359.           as_warn( "Subtracting symbol \"%s\"(segment\"%s\") is too hard. Absolute segment assumed.",
  1360.               exp . X_subtract_symbol -> sy_name,
  1361.               seg_name [(int) N_TYPE_seg [exp . X_subtract_symbol -> sy_type & N_TYPE]]);
  1362.           segment = SEG_ABSOLUTE;
  1363.           /* Leave exp . X_add_number alone. */
  1364.         }
  1365.       p = frag_more (nbytes);
  1366.       switch (segment)
  1367.         {
  1368.         case SEG_BIG:
  1369.           as_warn( "%s number illegal. Absolute 0 assumed.",
  1370.               exp . X_add_number > 0 ? "Bignum" : "Floating-Point");
  1371.           md_number_to_chars (p, (long)0, nbytes);
  1372.           break;
  1373.  
  1374.         case SEG_NONE:
  1375.           as_warn( "0 assumed for missing expression" );
  1376.           exp . X_add_number = 0;
  1377.           know( exp . X_add_symbol == NULL );
  1378.           /* fall into SEG_ABSOLUTE */
  1379.         case SEG_ABSOLUTE:
  1380.           get = exp . X_add_number;
  1381.           use = get & unmask;
  1382.           if ( (get & mask) && (get & mask) != mask )
  1383.         {        /* Leading bits contain both 0s & 1s. */
  1384.           as_warn("Value x%x truncated to x%x.", get, use);
  1385.         }
  1386.           md_number_to_chars (p, use, nbytes); /* put bytes in right order. */
  1387.           break;
  1388.  
  1389.         case SEG_DIFFERENCE:
  1390. #ifndef WORKING_DOT_WORD
  1391.           if(nbytes==2) {
  1392.         struct broken_word *x;
  1393.  
  1394.         x=(struct broken_word *)xmalloc(sizeof(struct broken_word));
  1395.         x->next_broken_word=broken_words;
  1396.         broken_words=x;
  1397.         x->frag=frag_now;
  1398.         x->word_goes_here=p;
  1399.         x->dispfrag=0;
  1400.         x->add=exp.X_add_symbol;
  1401.         x->sub=exp.X_subtract_symbol;
  1402.         x->addnum=exp.X_add_number;
  1403.         x->added=0;
  1404.         new_broken_words++;
  1405.         break;
  1406.           }
  1407.           /* Else Fall through into. . . */
  1408. #endif
  1409.         case SEG_BSS:
  1410.         case SEG_UNKNOWN:
  1411.         case SEG_TEXT:
  1412.         case SEG_DATA:
  1413. #ifdef SPARC
  1414.           fix_new (frag_now, p - frag_now -> fr_literal, nbytes,
  1415.                exp . X_add_symbol, exp . X_subtract_symbol,
  1416.                exp . X_add_number, 0, RELOC_32);
  1417. #endif
  1418. #ifdef NS32K
  1419.           fix_new_ns32k (frag_now, p - frag_now -> fr_literal, nbytes,
  1420.                exp . X_add_symbol, exp . X_subtract_symbol,
  1421.                exp . X_add_number, 0, 0, 2, 0, 0);
  1422. #endif
  1423. #if !defined(SPARC) && !defined(NS32K)
  1424.           fix_new (frag_now, p - frag_now -> fr_literal, nbytes,
  1425.                exp . X_add_symbol, exp . X_subtract_symbol,
  1426.                exp . X_add_number, 0);
  1427. #endif
  1428.           break;
  1429.  
  1430.         default:
  1431.           BAD_CASE( segment );
  1432.           break;
  1433.         }            /* switch(segment) */
  1434.     }            /* if(!need_pass_2) */
  1435.       c = * input_line_pointer ++;
  1436.     }                /* while(c==',') */
  1437.   input_line_pointer --;    /* Put terminator back into stream. */
  1438.   demand_empty_rest_of_line();
  1439. }                /* cons() */
  1440.  
  1441. /*
  1442.  *            big_cons()
  1443.  *
  1444.  * CONStruct more frag(s) of .quads, or .octa etc.
  1445.  * Makes 0 or more new frags.
  1446.  * If need_pass_2 == TRUE, generate no frag.
  1447.  * This understands only bignums, not expressions. Cons() understands
  1448.  * expressions.
  1449.  *
  1450.  * Constants recognised are '0...'(octal) '0x...'(hex) '...'(decimal).
  1451.  *
  1452.  * This creates objects with struct obstack_control objs, destroying
  1453.  * any context objs held about a partially completed object. Beware!
  1454.  *
  1455.  *
  1456.  * I think it sucks to have 2 different types of integers, with 2
  1457.  * routines to read them, store them etc.
  1458.  * It would be nicer to permit bignums in expressions and only
  1459.  * complain if the result overflowed. However, due to "efficiency"...
  1460.  */
  1461. void
  1462. big_cons(nbytes)        /* worker to do .quad etc statements */
  1463.                 /* clobbers input_line_pointer, checks */
  1464.                 /* end-of-line. */
  1465.      register int    nbytes;    /* 8=.quad 16=.octa ... */
  1466. {
  1467.   register char        c;    /* input_line_pointer -> c. */
  1468.   register int        radix;
  1469.   register long int    length;    /* Number of chars in an object. */
  1470.   register int        digit;    /* Value of 1 digit. */
  1471.   register int        carry;    /* For multi-precision arithmetic. */
  1472.   register int        work;    /* For multi-precision arithmetic. */
  1473.   register char *    p;    /* For multi-precision arithmetic. */
  1474.  
  1475.   extern char hex_value[];    /* In hex_value.c. */
  1476.  
  1477.   /*
  1478.    * The following awkward logic is to parse ZERO or more strings,
  1479.    * comma seperated. Recall an expression includes its leading &
  1480.    * trailing blanks. We fake a leading ',' if there is (supposed to
  1481.    * be) a 1st expression, and keep demanding 1 expression for each ','.
  1482.    */
  1483.   if (is_it_end_of_statement())
  1484.     {
  1485.       c = 0;            /* Skip loop. */
  1486.     }
  1487.   else
  1488.     {
  1489.       c = ',';            /* Do loop. */
  1490.       -- input_line_pointer;
  1491.     }
  1492.   while (c == ',')
  1493.     {
  1494.       ++ input_line_pointer;
  1495.       SKIP_WHITESPACE();
  1496.       c = * input_line_pointer;
  1497.       /* C contains 1st non-blank character of what we hope is a number. */
  1498.       if (c == '0')
  1499.     {
  1500.       c = * ++ input_line_pointer;
  1501.       if (c == 'x' || c=='X')
  1502.         {
  1503.           c = * ++ input_line_pointer;
  1504.           radix = 16;
  1505.         }
  1506.       else
  1507.         {
  1508.           radix = 8;
  1509.         }
  1510.     }
  1511.       else
  1512.     {
  1513.       radix = 10;
  1514.     }
  1515.       /*
  1516.        * This feature (?) is here to stop people worrying about
  1517.        * mysterious zero constants: which is what they get when
  1518.        * they completely omit digits.
  1519.        */
  1520.       if (hex_value[c] >= radix)
  1521.     {
  1522.       as_warn( "Missing digits. 0 assumed." );
  1523.     }
  1524.       bignum_high = bignum_low - 1; /* Start constant with 0 chars. */
  1525.       for(   ;   (digit = hex_value [c]) < radix;   c = * ++ input_line_pointer)
  1526.     {
  1527.       /* Multiply existing number by radix, then add digit. */
  1528.       carry = digit;
  1529.       for (p=bignum_low;   p <= bignum_high;   p++)
  1530.         {
  1531.           work = (*p & MASK_CHAR) * radix + carry;
  1532.           *p = work & MASK_CHAR;
  1533.           carry = work >> BITS_PER_CHAR;
  1534.         }
  1535.       if (carry)
  1536.         {
  1537.           grow_bignum();
  1538.           * bignum_high = carry & MASK_CHAR;
  1539.           know( (carry & ~ MASK_CHAR) == 0);
  1540.         }
  1541.     }
  1542.       length = bignum_high - bignum_low + 1;
  1543.       if (length > nbytes)
  1544.     {
  1545.       as_warn( "Most significant bits truncated in integer constant." );
  1546.     }
  1547.       else
  1548.     {
  1549.       register long int    leading_zeroes;
  1550.  
  1551.       for(leading_zeroes = nbytes - length;
  1552.           leading_zeroes;
  1553.           leading_zeroes --)
  1554.         {
  1555.           grow_bignum();
  1556.           * bignum_high = 0;
  1557.         }
  1558.     }
  1559.       if (! need_pass_2)
  1560.     {
  1561.       p = frag_more (nbytes);
  1562.       bcopy (bignum_low, p, (int)nbytes);
  1563.     }
  1564.       /* C contains character after number. */
  1565.       SKIP_WHITESPACE();
  1566.       c = * input_line_pointer;
  1567.       /* C contains 1st non-blank character after number. */
  1568.     }
  1569.   demand_empty_rest_of_line();
  1570. }                /* big_cons() */
  1571.  
  1572. static void
  1573. grow_bignum()            /* Extend bignum by 1 char. */
  1574. {
  1575.   register long int    length;
  1576.  
  1577.   bignum_high ++;
  1578.   if (bignum_high >= bignum_limit)
  1579.     {
  1580.       length = bignum_limit - bignum_low;
  1581.       bignum_low = xrealloc (bignum_low, length + length);
  1582.       bignum_high = bignum_low + length;
  1583.       bignum_limit = bignum_low + length + length;
  1584.     }
  1585. }                /* grow_bignum(); */
  1586.  
  1587. /*
  1588.  *            float_cons()
  1589.  *
  1590.  * CONStruct some more frag chars of .floats .ffloats etc.
  1591.  * Makes 0 or more new frags.
  1592.  * If need_pass_2 == TRUE, no frags are emitted.
  1593.  * This understands only floating literals, not expressions. Sorry.
  1594.  *
  1595.  * A floating constant is defined by atof_generic(), except it is preceded
  1596.  * by 0d 0f 0g or 0h. After observing the STRANGE way my BSD AS does its
  1597.  * reading, I decided to be incompatible. This always tries to give you
  1598.  * rounded bits to the precision of the pseudo-op. Former AS did premature
  1599.  * truncatation, restored noisy bits instead of trailing 0s AND gave you
  1600.  * a choice of 2 flavours of noise according to which of 2 floating-point
  1601.  * scanners you directed AS to use.
  1602.  *
  1603.  * In:    input_line_pointer -> whitespace before, or '0' of flonum.
  1604.  *
  1605.  */
  1606.  
  1607. void    /* JF was static, but can't be if VAX.C is goning to use it */
  1608. float_cons(float_type)        /* Worker to do .float etc statements. */
  1609.                 /* Clobbers input_line-pointer, checks end-of-line. */
  1610.      register float_type;    /* 'f':.ffloat ... 'F':.float ... */
  1611. {
  1612.   register char *    p;
  1613.   register char        c;
  1614.   int    length;    /* Number of chars in an object. */
  1615.   register char *    err;    /* Error from scanning floating literal. */
  1616.   char        temp [MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT];
  1617.  
  1618.   /*
  1619.    * The following awkward logic is to parse ZERO or more strings,
  1620.    * comma seperated. Recall an expression includes its leading &
  1621.    * trailing blanks. We fake a leading ',' if there is (supposed to
  1622.    * be) a 1st expression, and keep demanding 1 expression for each ','.
  1623.    */
  1624.   if (is_it_end_of_statement())
  1625.     {
  1626.       c = 0;            /* Skip loop. */
  1627.       ++ input_line_pointer;    /* -> past termintor. */
  1628.     }
  1629.   else
  1630.     {
  1631.       c = ',';            /* Do loop. */
  1632.     }
  1633.   while (c == ',')
  1634.     {
  1635.       /* input_line_pointer -> 1st char of a flonum (we hope!). */
  1636.       SKIP_WHITESPACE();
  1637.       /* Skip any 0{letter} that may be present. Don't even check if the
  1638.        * letter is legal. Someone may invent a "z" format and this routine
  1639.        * has no use for such information. Lusers beware: you get
  1640.        * diagnostics if your input is ill-conditioned.
  1641.        */
  1642.  
  1643.       if(input_line_pointer[0]=='0' && isalpha(input_line_pointer[1]))
  1644.       input_line_pointer+=2;
  1645.  
  1646.       err = md_atof (float_type, temp, &length);
  1647.       know( length <=  MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT);
  1648.       know( length > 0 );
  1649.       if (* err)
  1650.     {
  1651.       as_warn( "Bad floating literal: %s", err);
  1652.       ignore_rest_of_line();
  1653.       /* Input_line_pointer -> just after end-of-line. */
  1654.       c = 0;        /* Break out of loop. */
  1655.     }
  1656.       else
  1657.     {
  1658.       if ( ! need_pass_2)
  1659.         {
  1660.           p = frag_more (length);
  1661.           bcopy (temp, p, length);
  1662.         }
  1663.       SKIP_WHITESPACE();
  1664.       c = * input_line_pointer ++;
  1665.       /* C contains 1st non-white character after number. */
  1666.       /* input_line_pointer -> just after terminator (c). */
  1667.     }
  1668.     }
  1669.   -- input_line_pointer;        /* -> terminator (is not ','). */
  1670.   demand_empty_rest_of_line();
  1671. }                /* float_cons() */
  1672.  
  1673. /*
  1674.  *            stringer()
  1675.  *
  1676.  * We read 0 or more ',' seperated, double-quoted strings.
  1677.  *
  1678.  * Caller should have checked need_pass_2 is FALSE because we don't check it.
  1679.  */
  1680. static void
  1681. stringer(append_zero)        /* Worker to do .ascii etc statements. */
  1682.                 /* Checks end-of-line. */
  1683.      register int append_zero;    /* 0: don't append '\0', else 1 */
  1684. {
  1685.   /* register char *    p; JF unused */
  1686.   /* register int        length; JF unused */    /* Length of string we read, excluding */
  1687.                 /* trailing '\0' implied by closing quote. */
  1688.   /* register char *    where; JF unused */
  1689.   /* register fragS *    fragP; JF unused */
  1690.   register int c;
  1691.  
  1692.   /*
  1693.    * The following awkward logic is to parse ZERO or more strings,
  1694.    * comma seperated. Recall a string expression includes spaces
  1695.    * before the opening '\"' and spaces after the closing '\"'.
  1696.    * We fake a leading ',' if there is (supposed to be)
  1697.    * a 1st, expression. We keep demanding expressions for each
  1698.    * ','.
  1699.    */
  1700.   if (is_it_end_of_statement())
  1701.     {
  1702.       c = 0;            /* Skip loop. */
  1703.       ++ input_line_pointer;    /* Compensate for end of loop. */
  1704.     }
  1705.   else
  1706.     {
  1707.       c = ',';            /* Do loop. */
  1708.     }
  1709.   for (   ;   c == ',';   c = *input_line_pointer ++)
  1710.     {
  1711.       SKIP_WHITESPACE();
  1712.       if (* input_line_pointer == '\"')
  1713.     {
  1714.       ++ input_line_pointer; /* -> 1st char of string. */
  1715.       while ( (c = next_char_of_string()) >= 0)
  1716.         {
  1717.           FRAG_APPEND_1_CHAR( c );
  1718.         }
  1719.       if (append_zero)
  1720.         {
  1721.           FRAG_APPEND_1_CHAR( 0 );
  1722.         }
  1723.       know( input_line_pointer [-1] == '\"' );
  1724.     }
  1725.       else
  1726.     {
  1727.       as_warn( "Expected \"-ed string" );
  1728.     }
  1729.       SKIP_WHITESPACE();
  1730.     }
  1731.   -- input_line_pointer;
  1732.   demand_empty_rest_of_line();
  1733. }                /* stringer() */
  1734.  
  1735. static int
  1736. next_char_of_string ()
  1737. {
  1738.   register int c;
  1739.  
  1740.   c = * input_line_pointer ++;
  1741.   switch (c)
  1742.     {
  1743.     case '\"':
  1744.       c = -1;
  1745.       break;
  1746.  
  1747.     case '\\':
  1748.       switch (c = * input_line_pointer ++)
  1749.     {
  1750.     case 'b':
  1751.       c = '\b';
  1752.       break;
  1753.  
  1754.     case 'f':
  1755.       c = '\f';
  1756.       break;
  1757.  
  1758.     case 'n':
  1759.       c = '\n';
  1760.       break;
  1761.  
  1762.     case 'r':
  1763.       c = '\r';
  1764.       break;
  1765.  
  1766.     case 't':
  1767.       c = '\t';
  1768.       break;
  1769.  
  1770.     case '\\':
  1771.     case '"':
  1772.       break;        /* As itself. */
  1773.  
  1774.     case '0':
  1775.     case '1':
  1776.     case '2':
  1777.     case '3':
  1778.     case '4':
  1779.     case '5':
  1780.     case '6':
  1781.     case '7':
  1782.     case '8':
  1783.     case '9':
  1784.       {
  1785.         long int number;
  1786.  
  1787.         for (number = 0;   isdigit(c);   c = * input_line_pointer ++)
  1788.           {
  1789.         number = number * 8 + c - '0';
  1790.           }
  1791.         c = number;
  1792.       }
  1793.       -- input_line_pointer;
  1794.       break;
  1795.  
  1796.     case '\n':
  1797. /*      as_fatal( "Unterminated string - use app!" ); */
  1798. /* To be compatible with BSD 4.2 as: give the luser a linefeed!! */
  1799.       c = '\n';
  1800.       break;
  1801.  
  1802.     default:
  1803.       as_warn( "Bad escaped character in string, '?' assumed" );
  1804.       c = '?';
  1805.       break;
  1806.     }
  1807.       break;
  1808.  
  1809.     default:
  1810.       break;
  1811.     }
  1812.   return (c);
  1813. }
  1814.  
  1815. static segT
  1816. get_segmented_expression ( expP )
  1817.      register expressionS *    expP;
  1818. {
  1819.   register segT        retval;
  1820.  
  1821.   if ( (retval = expression( expP )) == SEG_PASS1 || retval == SEG_NONE || retval == SEG_BIG )
  1822.     {
  1823.       as_warn("Expected address expression: absolute 0 assumed");
  1824.       retval = expP -> X_seg = SEG_ABSOLUTE;
  1825.       expP -> X_add_number   = 0;
  1826.       expP -> X_add_symbol   = expP -> X_subtract_symbol = 0;
  1827.     }
  1828.   return (retval);        /* SEG_ ABSOLUTE,UNKNOWN,DATA,TEXT,BSS */
  1829. }
  1830.  
  1831. static segT
  1832. get_known_segmented_expression ( expP )
  1833.      register expressionS *    expP;
  1834. {
  1835.   register segT        retval;
  1836.   register char *    name1;
  1837.   register char *    name2;
  1838.  
  1839.   if (   (retval = get_segmented_expression (expP)) == SEG_UNKNOWN
  1840.       )
  1841.     {
  1842.       name1 = expP -> X_add_symbol ? expP -> X_add_symbol -> sy_name : "";
  1843.       name2 = expP -> X_subtract_symbol ? expP -> X_subtract_symbol -> sy_name : "";
  1844.       if ( name1 && name2 )
  1845.     {
  1846.       as_warn("Symbols \"%s\" \"%s\" are undefined: absolute 0 assumed.",
  1847.           name1, name2);
  1848.     }
  1849.       else
  1850.     {
  1851.       as_warn("Symbol \"%s\" undefined: absolute 0 assumed.",
  1852.           name1 ? name1 : name2);
  1853.     }
  1854.       retval = expP -> X_seg = SEG_ABSOLUTE;
  1855.       expP -> X_add_number   = 0;
  1856.       expP -> X_add_symbol   = expP -> X_subtract_symbol = NULL;
  1857.     }
  1858.  know(   retval == SEG_ABSOLUTE || retval == SEG_DATA || retval == SEG_TEXT || retval == SEG_BSS || retval == SEG_DIFFERENCE );
  1859.   return (retval);
  1860. }                /* get_known_segmented_expression() */
  1861.  
  1862.  
  1863.  
  1864. /* static */ long int /* JF was static, but can't be if the MD pseudos are to use it */
  1865. get_absolute_expression ()
  1866. {
  1867.   expressionS    exp;
  1868.   register segT s;
  1869.  
  1870.   if ( (s = expression(& exp)) != SEG_ABSOLUTE )
  1871.     {
  1872.       if ( s != SEG_NONE )
  1873.     {
  1874.       as_warn( "Bad Absolute Expression, absolute 0 assumed.");
  1875.     }
  1876.       exp . X_add_number = 0;
  1877.     }
  1878.   return (exp . X_add_number);
  1879. }
  1880.  
  1881. static char            /* return terminator */
  1882. get_absolute_expression_and_terminator( val_pointer)
  1883.      long int *        val_pointer; /* return value of expression */
  1884. {
  1885.   * val_pointer = get_absolute_expression ();
  1886.   return ( * input_line_pointer ++ );
  1887. }
  1888.  
  1889. /*
  1890.  *            demand_copy_C_string()
  1891.  *
  1892.  * Like demand_copy_string, but return NULL if the string contains any '\0's.
  1893.  * Give a warning if that happens.
  1894.  */
  1895. static char *
  1896. demand_copy_C_string (len_pointer)
  1897.      int *    len_pointer;
  1898. {
  1899.   register char *    s;
  1900.  
  1901.   if (s = demand_copy_string (len_pointer))
  1902.     {
  1903.       register int    len;
  1904.  
  1905.       for (len = * len_pointer;
  1906.        len > 0;
  1907.        len--)
  1908.     {
  1909.       if (* s == 0)
  1910.         {
  1911.           s = 0;
  1912.           len = 1;
  1913.           * len_pointer = 0;
  1914.           as_warn( "This string may not contain \'\\0\'" );
  1915.         }
  1916.     }
  1917.     }
  1918.   return (s);
  1919. }
  1920.  
  1921. /*
  1922.  *            demand_copy_string()
  1923.  *
  1924.  * Demand string, but return a safe (=private) copy of the string.
  1925.  * Return NULL if we can't read a string here.
  1926.  */
  1927. static char *
  1928. demand_copy_string (lenP)
  1929.      int *    lenP;
  1930. {
  1931.   register int        c;
  1932.   register int        len;
  1933.        char *    retval;
  1934.  
  1935.   len = 0;
  1936.   SKIP_WHITESPACE();
  1937.   if (* input_line_pointer == '\"')
  1938.     {
  1939.       input_line_pointer ++;    /* Skip opening quote. */
  1940.       while ( (c = next_char_of_string()) >= 0 ) {
  1941.       obstack_1grow ( ¬es, c );
  1942.       len ++;
  1943.     }
  1944.       /* JF this next line is so demand_copy_C_string will return a null
  1945.          termanated string. */
  1946.       obstack_1grow(¬es,'\0');
  1947.       retval=obstack_finish( ¬es);
  1948.   } else {
  1949.       as_warn( "Missing string" );
  1950.       retval = NULL;
  1951.       ignore_rest_of_line ();
  1952.     }
  1953.   * lenP = len;
  1954.   return (retval);
  1955. }
  1956.  
  1957. /*
  1958.  *        is_it_end_of_statement()
  1959.  *
  1960.  * In:    Input_line_pointer -> next character.
  1961.  *
  1962.  * Do:    Skip input_line_pointer over all whitespace.
  1963.  *
  1964.  * Out:    TRUE if input_line_pointer -> end-of-line.
  1965.  */
  1966. static int
  1967. is_it_end_of_statement()
  1968. {
  1969.   SKIP_WHITESPACE();
  1970.   return (is_end_of_line [* input_line_pointer]);
  1971. }
  1972.  
  1973. void
  1974. equals(sym_name)
  1975. char *sym_name;
  1976. {
  1977.   register struct symbol * symbolP; /* symbol we are working with */
  1978.  
  1979.   if(sym_name[0]=='.' && sym_name[1]=='\0') {
  1980.     /* Turn '. = mumble' into a .org mumble */
  1981.     register segT segment;
  1982.     expressionS exp;
  1983.     register char *p;
  1984.  
  1985.     if(input_line_pointer[1]=='=')
  1986.       input_line_pointer+=2;
  1987.     else
  1988.       *input_line_pointer++='=';        /* Put it back */
  1989.     if(*input_line_pointer==' ' || *input_line_pointer=='\t')
  1990.         input_line_pointer++;
  1991.     segment = get_known_segmented_expression(& exp);
  1992.     if ( ! need_pass_2 ) {
  1993.       if (segment != now_seg && segment != SEG_ABSOLUTE)
  1994.         as_warn("Illegal segment \"%s\". Segment \"%s\" assumed.",
  1995.                 seg_name [(int) segment], seg_name [(int) now_seg]);
  1996.       p = frag_var (rs_org, 1, 1, (relax_substateT)0, exp.X_add_symbol,
  1997.                     exp.X_add_number, (char *)0);
  1998.       * p = 0;
  1999.     } /* if (ok to make frag) */
  2000.     return;
  2001.   }
  2002.  
  2003.   symbolP=symbol_find_or_make(sym_name);
  2004.   if(input_line_pointer[1]=='=')
  2005.     input_line_pointer+=2;
  2006.   else
  2007.     *input_line_pointer++='=';        /* Put it back */
  2008.   pseudo_set(symbolP);
  2009. }
  2010.  
  2011. /* end: read.c */
  2012.